home *** CD-ROM | disk | FTP | other *** search
/ Resource for Source: C/C++ / Resource for Source - C-C++.iso / codelib2 / v_02_03 / 2n03038a < prev    next >
Encoding:
Text File  |  1995-11-01  |  17.8 KB  |  421 lines
  1.  
  2. /* plot1024.c Copyright 1990 by Gary R. Olhoeft */
  3. /* 
  4.    Compile with the MicroWay NDP C-386 v2.1.0 compiler and run
  5.    with the Phar Lap 386|DOS extender. 
  6. */
  7. #include <dos.h>
  8. #include <stdio.h>
  9. #include <math.h>
  10. #include <grex.h>    /* MicroWay NDP C-386 extended graphics library */
  11. #include <reg8514.h> /* VESA 8514/A registers after Richter & Smith (1990) */
  12. #define outpw(p,v) dx = p; ax = v; asm(dx,ax,"     out     dx,ax")
  13. unsigned char **image();
  14. void free_image();
  15. void plot_image_tseng();
  16. void grey_vga();
  17. void plot_image_hgsc();
  18. void grey_hgsc();
  19. void plot_image_8514();
  20. void grey_8514();
  21. void set_hgsc();
  22.   union REGS reg;                      /* required by DOS INT */
  23.   int _pmode;
  24. /* VESA 8514/A 1024x768x256 timing control register parameters */
  25.   static short  initRegs[] =
  26.       { DISP_CNTL, ADVFUNC_CNTL, V_TOTAL, V_SYNC_STRT,
  27.         V_DISP, H_TOTAL, H_SYNC_STRT, H_DISP,
  28.         H_SYNC_WID, V_SYNC_WID, DISP_CNTL, 0 };
  29.   static short  mode1024x8[] =
  30.       { 0x0053, 0x0007, 0x0660, 0x0600,
  31.         0x05FB, 0x009D, 0x0081, 0x007F,
  32.         0x0016, 0x0008, 0x0033 };
  33.   int _pmode;
  34.   unsigned char hpgl_page;
  35.  
  36. main ()
  37.   {
  38.   reg$eax unsigned short ax, v; /* required by inline assembler */
  39.   reg$edx unsigned short dx, p;
  40.   FILE *stream_in;
  41.   char file_in[80];  
  42.   unsigned char str[4096], **image_array;
  43.   int i,j,k;
  44.   char hstr[20];
  45.   asm("hstdata  equ  0C7000h");  /* HGSC 34010 host addresses */
  46.   asm("hstctrl  equ  0C7D00h");  /* for inline assembler use */
  47.   asm("hstadrl  equ  0C7E00h");
  48.   asm("hstadrh  equ  0C7F00h");  
  49.   _pmode=0x8000;                 /* binary disk access */
  50.  
  51. /* read in the image to be displayed (Jupiter's moon Io from Voyager I) */
  52.     strcpy(file_in,"e:\\img\\c1636828.img\0"); 
  53.     if ((stream_in = fopen(file_in,"r")) == NULL)
  54.        {
  55.          printf("Cannot find File %s\n",file_in); exit(0);
  56.        }
  57.     else
  58.        {
  59.          printf("Reading Image File %s\n",file_in);
  60.          i=fread(str,1,2*836,stream_in); /* ignore PDS header */
  61.          image_array = image(768,1024);  /* create space for image */
  62.          for (i=0; i<768; i++) fread(&image_array[i][0], 1, 836, stream_in);
  63.          i=fclose(stream_in);
  64.        }
  65.      
  66. /* Tseng 4000 STB EM-16 Plus PowerGraph 1024x768x256 */
  67.     blk_mb(str, 0x34, 0xC0000, 500); /* read BIOS area */
  68.     k = -1;
  69.     strcpy(hstr," STB \0");
  70.     for (i=0; i<480; i++) {j = memcmp(str+i,hstr,5); if (j==0) k=j;}
  71.     if (k != -1)
  72.       {
  73.         k = -1;
  74.         strcpy(hstr,"AWARD\0");
  75.         for (i=0; i<480; i++) { j = memcmp(str+i,hstr,5); if (j==0) k = j;}
  76.         if (k != -1) /* Tseng 4000 (STB EM-16 Plus PowerGraph) found */
  77.           {
  78.             reg.b.ah = 0;
  79.             reg.b.al = 56; 
  80.             int386(0x10,®,®);        /* set mode */
  81.             /* set grey scale using MicroWay libGREX palette function */
  82.             /* up to 2. sec */    
  83.             for (i=0; i<256; i++) {j = i>>2; vga_palette(i,j,j,j);}
  84.             plot_image_tseng(image_array); /* plot image in 0.193 sec */
  85.             getch();                       /* wait for keypress */
  86.           }
  87.       }
  88.  
  89. /* IBM 8514/A 1024x768x256 setup after Richter and Smith (1990) */
  90.     outp(DAC_MASK, 0x00); /* blank screen by turning all planes off */
  91.     outpw(SUBSYS_CNTL, GPCTRL_RESET | CHPTEST_NORMAL); /* reset 8514/A */
  92.     outpw(SUBSYS_CNTL, GPCTRL_ENAB | CHPTEST_NORMAL);
  93.     outpw(ERR_TERM, 0xFFFF);      /* test for 8514/A card */
  94.     if (inpw(ERR_TERM) == 0xFFFF) /* 8514/A card found */
  95.       {
  96.         i = inpw(SUBSYS_STAT);        /* get board status information */
  97.         if ((i & MONITORID_MASK) == MONITORID_8514) /* 1024x768 monitor */
  98.           {
  99.             outpw(MULTIFUNC_CNTL, MEM_CNTL | VRTCFG_4 | HORCFG_8);
  100.             i = 0; /* setup 1024x768 timing parameters */
  101.             while (initRegs[i]) { outpw(initRegs[i], mode1024x8[i]); i++;}
  102.             outpw(DAC_MASK, 0xFF);        /* enable all 8 planes */
  103.             outpw(FRGD_MIX, FSS_FRGDCOL | MIX_REPLACE);
  104.             outpw(BKGD_MIX, BSS_BKGDCOL | MIX_REPLACE);
  105.             /* clip to full drawable space (0,0 to 1023,1023) */
  106.             outpw(MULTIFUNC_CNTL, SCISSORS_T | 0x000);
  107.             outpw(MULTIFUNC_CNTL, SCISSORS_L | 0x000);
  108.             outpw(MULTIFUNC_CNTL, SCISSORS_B | 0x3FF);
  109.             outpw(MULTIFUNC_CNTL, SCISSORS_R | 0x3FF);
  110.             outpw(WRT_MASK, 0xFFFF);      /* enable writes to all planes */
  111.             outpw(MULTIFUNC_CNTL, PIX_CNTL | 0); /* clear lower bits */
  112.             WaitQueue(6);                 /* wait until 8514 queue ready */
  113.             outpw(FRGD_COLOR, 0);         /* set color */
  114.             outpw(CUR_X, 0);              /* set origin */
  115.             outpw(CUR_Y, 0);
  116.             outpw(MAJ_AXIS_PCNT, 1023);   /* set size */
  117.             outpw(MULTIFUNC_CNTL, MIN_AXIS_PCNT | 1023);
  118.             outpw(CMD, CMD_RECT | INC_Y | INC_X | DRAW | PLANAR | WRTDATA);
  119.             WaitQueue(4);
  120.             outpw(CUR_X, 0);              /* reset draw position to (0,0) */
  121.             outpw(CUR_Y, 0);
  122.             outpw(FRGD_COLOR, 0xFFFF);    /* foreground all on */
  123.             outpw(BKGD_COLOR, 0);         /* background all off */
  124.             grey_8514();                  /* setup 8514 grey scale 0.00087 sec*/
  125.             outpw(FRGD_MIX, FSS_PCDATA | MIX_REPLACE);
  126.             plot_image_8514(image_array); /* plot image in 0.385 sec */
  127.             getch();                      /* wait for key press */
  128.             outpw(ADVFUNC_CNTL, 6);       /* restore 8514/A to VGA */
  129.           }
  130.       }
  131.  
  132. /* Hercules Graphics Station Card GB1024 TI34010 1024x768x256 */
  133.     blk_mb(str, 0x34, 0xC0000, 500); /* read BIOS area */
  134.     k = -1;
  135.     strcpy(hstr,"Hercules\0");
  136.     for (i=0; i<480; i++) {j = memcmp(str+i,hstr,8); if (j==0) k=j;}
  137.     if (k != -1)
  138.       {
  139.         k = -1;
  140.         strcpy(hstr,"Graphics Station\0");
  141.         for (i=0; i<480; i++) { j = memcmp(str+i,hstr,16); if (j==0) k = j;}
  142.         if (k != -1)                       /* HGSC found */
  143.           {
  144.             set_hgsc();                    /* set 34010 mode 1024x768 */
  145.             grey_hgsc();                   /* setup grey scale 0.00082 sec */
  146.             plot_image_hgsc(image_array);  /* plot image in 0.275 sec */
  147.             getch();                       /* wait for key press */
  148.             setvga();                      /* restore HGSC to VGA modes */
  149.             /* setvga is found in TECH Specialist, v.1, n.5, p.35 */
  150.           }
  151.       }
  152.  
  153.     free_image(image_array, 768);     /* free image memory */
  154.     set_video_mode(0x02);             /* restore text mode */
  155. } 
  156.  
  157. unsigned char **image(row,col)
  158. int row,col;
  159. {   /* allocates 8-bit 2D image matrix with range [0...row-1][0...col-1] */
  160.     int i;
  161.     unsigned char **m; /* no error checking: assumes enough memory exists */
  162.     m = (unsigned char **) malloc((unsigned)(row)*sizeof(unsigned char *));
  163.     for (i=0; i<row; i++)
  164.        m[i] = (unsigned char *) malloc((unsigned)(col)*sizeof(unsigned char));
  165.     return m;
  166. }
  167.  
  168. void free_image(m,row)
  169. unsigned char **m;
  170. int row;
  171. {        /* frees memory malloc'd by image function in Listing 2 */
  172.     int i;
  173.     for (i=row-1; i>=0; i--) free(m[i]);
  174.     free(m);
  175. }
  176.  
  177. void plot_image_tseng(image_array) /* Tseng 4000 chipset 1024x768x256 */
  178. unsigned char **image_array;
  179. { 
  180.     reg$eax unsigned short ax; /* required by inline assembler */
  181.     reg$esi unsigned esi;
  182.     reg$edi unsigned edi;
  183.     reg$ecx unsigned ecx;
  184.     int j, jj, k, vcol, row;
  185.     unsigned int cm;
  186.     unsigned short pel;
  187.     vcol = 1024;                        /* length of horizontal screen row */
  188.     row = -vcol;
  189.     asm("     push   es");              /* save es register */
  190.     asm("     mov    ax, 034h");        /* set Phar Lap LDT to access */
  191.     asm("     mov    es, ax");          /* first megabyte of real memory */
  192.     hpgl_page = 99;                     /* force first page */
  193.     for (j=0; j<768; j++)               /* vertical lines (rows) on screen */
  194.       {
  195.         row += vcol;
  196.         ax = (unsigned char)(row >> 16);/* divide by 64k to determine page */ 
  197.         if (ax!=hpgl_page)              /* don't page unless changed */
  198.           {
  199.             hpgl_page = ax;             /* save new page */
  200.             asm("     pushfd");         /* save flags */
  201.             asm("     cli     ");       /* clear interrupts */
  202.          asm(ax,"     or      al,40h"); /* 8 64k pages */
  203.             asm("     mov     dx,3cdh");/* GDC segment select register */
  204.             asm("     out     dx,al");  /* select page */
  205.             asm("     popfd     ");     /* restore flags */
  206.           }
  207.         esi = &image_array[j][0];       /* 386 address of image row */
  208.         cm = (row % 65536);             /* determine where in 64k page */
  209.         edi = 655360 + cm;              /* VGA video address of row */
  210.         ecx = 256;                      /* number of pixels/4 to move */
  211.         asm(ecx,esi,edi, " rep movsd"); /* 256 double word mov's */
  212.       }
  213.     asm("     pop    es");              /* restore es register */
  214. }
  215.  
  216.  
  217. void grey_8514()
  218. {
  219.   asm("     xor    eax,eax");        /* eax = 0 */
  220.   asm("     mov    dx,02ECh");          
  221.   asm("     out    dx,al");          /* starting palette index */
  222.   asm("     mov    dx,02EDh");
  223.   asm("     xor    ebx,ebx");        /* ebx = 0 */
  224.   asm("lll: mov    eax,ebx");
  225.   asm("     shr    eax,2");          /* divide by 4 for 6-bit palette */
  226.   asm("     out    dx,al");          /* red */
  227.   asm("     out    dx,al");          /* green */
  228.   asm("     out    dx,al");          /* blue */
  229.   asm("     inc    ebx"); 
  230.   asm("     cmp    ebx,256");        /* 256 palette entries */
  231.   asm("     jl     lll");
  232. }
  233.  
  234. void plot_image_8514(image_array)
  235. unsigned char **image_array;
  236. { 
  237.   reg$eax unsigned eax;                /* required by inline assembler */
  238.   reg$eax unsigned short ax, v;
  239.   reg$ecx unsigned ecx;
  240.   reg$edx unsigned short dx, p;
  241.   reg$esi unsigned esi;
  242.   int i;
  243.   unsigned short pel;
  244.   WaitQueue(8);                        /* wait until queue is empty */
  245.   outpw(MULTIFUNC_CNTL, 0);            /* line width 0 = single pixel */
  246.   outpw(MAJ_AXIS_PCNT, 1023);          /* line length = 1024 pixels */
  247.   pel = BYTSEQ | _16BIT | CMD_LINE | PCDATA | LINETYPE | DRAW | WRTDATA;
  248.   for (i=0; i<768; i++)                /* cycle through rows (y) */
  249.     {
  250.       outpw(CUR_Y, (short)(i));        /* y position in 8514/A memory */
  251.       outpw(CUR_X, 0);                 /* x position in 8514/A memory */
  252.       outpw(CMD, pel);                 /* setup transfer command */
  253.       dx = PIX_TRANS;                  /* port for transfer to 8514 */
  254.       ecx = 512;                       /* 16-bit words to move */
  255.       esi = &image_array[i][0];        /* address of line in 386 memory */
  256.       asm(dx, esi, ecx, "rep   outsw");/* send whole line of pixel pairs */
  257.     }
  258. }
  259.  
  260. void set_hgsc()
  261. {
  262.   asm("     push    es");        /* save es register */
  263.   asm("     mov     ax,034h");   /* setup Phar Lap LDT to first MByte */
  264.   asm("     mov     es,ax");
  265.   asm("     mov     cx,0C000h");
  266.   asm("     mov     ax,0B040h"); /* dpyctl = enable video, interlaced */
  267.   asm("     and     ax,7FFFh");  /* blank video */
  268.   asm("     mov     bx,80h");
  269.   asm("     call    write");     /* write ax to cx:bx in 34010 */
  270.   asm("     mov     ax,157");    /* htotal */
  271.   asm("     mov     bx,30h");   
  272.   asm("     call    write");  
  273.   asm("     mov     ax,156");    /* hsblnk; hsblnk-heblnk = 1024/8 */
  274.   asm("     mov     bx,20h");   
  275.   asm("     call    write");     
  276.   asm("     mov     ax,28");     /* heblnk; increase to move screen right */
  277.   asm("     mov     bx,10h");   
  278.   asm("     call    write");     
  279.   asm("     mov     ax,21");     /* hesync */
  280.   asm("     mov     bx,0");     
  281.   asm("     call    write"); 
  282.   asm("     mov     ax,407");    /* vtotal */
  283.   asm("     mov     bx,70h");   
  284.   asm("     call    write");   
  285.   asm("     mov     ax,405");    /* vsblnk; vsblnk-veblnk = 768/2 */
  286.   asm("     mov     bx,60h");   
  287.   asm("     call    write");   
  288.   asm("     mov     ax,21");     /* veblnk; increase to move screen down */
  289.   asm("     mov     bx,50h");   
  290.   asm("     call    write");    
  291.   asm("     mov     ax,4");      /* vesync */
  292.   asm("     mov     bx,40h");   
  293.   asm("     call    write");   
  294.   asm("     mov     ax,0");      /* dpytap */
  295.   asm("     mov     bx,1B0h");  
  296.   asm("     call    write");   
  297.   asm("     mov     ax,0FFFCh"); /* dpystrt; 1 scan line per refresh */
  298.   asm("     mov     bx,90h"); 
  299.   asm("     call    write");   
  300.   asm("     mov     cx,600h");      
  301.   asm("     mov     bx,0E0h");   /* 0600:00E0 write config.2 reg. */
  302.   asm("     mov     ax,0Fh");    /* bppsync = 8 bpp, -horz, -vert sync */
  303.   asm("     call    write");
  304.   asm("     mov     bx,0C0h");   /* 0600:00C0 write config.1 reg. */
  305.   asm("     mov     ax,12");     /* cmdfreq = 44.9 MHz, cmd & overlay */
  306.   asm("     call    write");
  307.   asm("     mov     bx,20h");    /* 0600:0020 = cmd register in DAC */
  308.   asm("     mov     ax,05Bh");   /* daclut = 8bpp + 24-bit LUT, no overlay */
  309.   asm("     call    write");
  310.   asm("     mov     bx,0C0h");   /* 0600:00C0 = write config. 1 */
  311.   asm("     mov     ax,4");      /* normfreq = 44.9 Mhz, normal palette */
  312.   asm("     call    write");
  313.   asm("     mov     ax,0C000h"); /* no autoincrement */
  314.   asm("     mov     es:hstctrl,ax"); /* setup 34010 */
  315.   asm("     mov     cx,0C000h");
  316.   asm("     mov     ax,0B040h"); /* dpyctl */
  317.   asm("     mov     bx,80h");
  318.   asm("     call    write");     /* enable video */
  319.   asm("     pop     es");        /* restore es register */
  320.   asm("     ret");               /* return to calling program */
  321.  
  322.   asm("write   proc    near");   /* create subroutine */
  323.   asm("        mov     es:hstadrl,bx");  
  324.   asm("        mov     es:hstadrh,cx");  
  325.   asm("        mov     es:hstdata,ax"); /* write ax to cx:bx */
  326.   asm("        ret");
  327.   asm("write   endp");
  328. }
  329.  
  330. void grey_hgsc()
  331. {
  332.   asm("     push   es");             /* save es register */
  333.   asm("     mov    ax,034h");        /* setup Phar Lap LDT to first Mbyte */
  334.   asm("     mov    es,ax");
  335.   asm("     pushfd");                /* save flags */
  336.   asm("     cli");                   /* disable interrupts */
  337.   asm("     mov    ax,0C000h");
  338.   asm("     mov    es:hstctrl,ax");  /* turn off autoincrement */
  339.   asm("     mov    ax,01E0h");
  340.   asm("     mov    es:hstadrl,ax");
  341.   asm("     mov    ax,0600h");
  342.   asm("     mov    es:hstadrh,ax");  
  343.   asm("     mov    cx,es:hstdata");  /* read & save config 2 */
  344.   asm("     mov    ax,80h");
  345.   asm("     mov    es:hstadrl,ax");
  346.   asm("     mov    ax,0C000h");
  347.   asm("     mov    es:hstadrh,ax");
  348.   asm("     mov    ax,es:hstdata");  /* read dpyctl */
  349.   asm("     push   eax");            /* save eax (dpyctl) */
  350.   asm("     and    ax,7FFFh");
  351.   asm("     mov    es:hstdata,ax");  /* blank video */
  352.   asm("     mov    ax,00E0h");
  353.   asm("     mov    es:hstadrl,ax");
  354.   asm("     mov    ax,0600h");
  355.   asm("     mov    es:hstadrh,ax");  
  356.   asm("     mov    ax,0Ch");         /* -H -V sync VGA control VRAM */
  357.   asm("     mov    es:hstdata,ax");  /* write config 2 for VGA */
  358.   asm("     xor    eax,eax");        /* can only change palette in VGA */
  359.   asm("     mov    dx,03C8h");
  360.   asm("     out    dx,al");          /* starting palette index */
  361.   asm("     mov    dx,03C9h");
  362.   asm("     xor    eax,eax");
  363.   asm("ll:  out    dx,al");          /* red */
  364.   asm("     out    dx,al");          /* green */
  365.   asm("     out    dx,al");          /* blue */
  366.   asm("     inc    eax"); 
  367.   asm("     cmp    eax,256");        /* 256 palette entries */
  368.   asm("     jl     ll");
  369.   asm("     mov    es:hstdata,cx");  /* restore original config 2 */
  370.   asm("     mov    ax,80h");
  371.   asm("     mov    es:hstadrl,ax");
  372.   asm("     mov    ax,0C000h");
  373.   asm("     mov    es:hstadrh,ax");
  374.   asm("     pop    eax");            /* get saved eax */
  375.   asm("     mov    es:hstdata,ax");  /* restore dpyctl, enable video */
  376.   asm("     popfd");                 /* restore flags (interrupts) */
  377.   asm("     pop    es");             /* restore es register */
  378. }
  379.  
  380. void plot_image_hgsc(image_array)   /* 1024x768x256 HGSC */
  381. unsigned char **image_array;
  382. { 
  383.   reg$ebx unsigned ebx;             /* required by inline assembler */
  384.   reg$esi unsigned esi;
  385.   esi = &image_array[0][0];         /* image array address in 386 memory */
  386.   ebx = 12;                         /* lines = height/64 */
  387.   asm(esi,ebx,"     push   es");    /* send esi & ebx to assembler, save es */
  388.   asm("     mov    ax,034h");       /* setup Phar Lap LDT to first Mbyte */
  389.   asm("     mov    es,ax");
  390.   asm("     mov    ax,0D800h");
  391.   asm("     mov    es:hstctrl,ax"); /* setup 34010 for transfer */
  392.   asm("     cld");                  /* set direction of movsd */
  393.   asm("     xor    eax,eax");       /* eax = 0 */
  394.   asm("     mov    es:hstadrl,ax");
  395.   asm("     mov    es:hstadrh,ax"); /* starting address in 34010 memory */
  396.   asm("     mov    dx,46E8h");
  397.   asm("     out    dx,ax");         /* disable VGA */ 
  398.  
  399.   asm("     align  4");
  400.   asm("slp: lea    edi,es:[655360]"); /* starting address of hstdata shadow */
  401.   asm("     mov    eax,64");        /* 64 lines per shadow page */
  402.   asm("llp: mov    ecx,256");       /* 256 double words per 1024 pixel line */
  403.   asm("rep  movsd");                /* move 1024 pixel line */
  404.   asm("     add    esi,8");         /* skip array pointers */
  405.   asm("     dec    eax");
  406.   asm("     cmp    eax,0");
  407.   asm("     jnz    llp");           /* loop 64 lines/page */
  408.   asm("     dec    ebx");
  409.   asm("     cmp    ebx,0");
  410.   asm("     jnz    slp");           /* loop 12 pages/image */
  411.  
  412.   asm("     mov    dx,46E8h");
  413.   asm("     mov    ax,0Eh");
  414.   asm("     out    dx,ax");         /* enable VGA */
  415.   asm("     mov    ax,0C000h");     /* turn off autoincrement */
  416.   asm("     mov    es:hstctrl,ax");
  417.   asm("     pop    es");            /* restore es register */
  418. }
  419.  
  420.  
  421.